Matrix builds

Great work so far! By targeting specific versions of Node, we've configured a build matrix which allow us to test across multiple operating systems, platforms, and language versions. See Configuring a matrix build in GitHub Help if you'd like to learn more.

I'll respond when you commit the changes in the comment below.

New Job

Great, if you look at the logs now, you'll notice that multiple builds will exist: 4 build to be exact! That's because for each of the 2 operating systems we're running tests against 2 versions so: 2 OS ✖️ 2 Node.js versions = 4 builds.

Our custom workflow now accounts for:

• ✅ test against multiple targets so that we know if our supported operating systems and Node.js versions are working

Step 9: Use multiple jobs

Let's now try to create a dedicated test job and satisfy the second item in our custom workflow checklist.

This will allow us to separate the build and test functions of our workflow into more than one job that will run when our workflow is triggered.

Activity: Edit your workflow file to separate build and test jobs

1. Edit your workflow file
2. Create a new job called "test" as follows (we'll use ellipses ... to only show the parts of the workflow we're interested in, but you should not copy the ellipses directly):

   name: Node CI
   
   on: [push]
   
   jobs:
     build:
       ...
     test:
       ...

3. In the build job, include the following portions of your existing workflow:

   build:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: npm install and build webpack
         run: |
           npm install
           npm run build

4. In the newly created test job, include the following portions of your existing workflow:

   test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         os: [ubuntu-latest, windows-2016]
         node-version: [12.x, 14.x]
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
     - name: npm install, and test
       run: |
         npm install
         npm test
       env:
         CI: true

name: Node CI

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2
      - name: npm install and build webpack
        run: |
          npm install
          npm run build

  test:

    runs-on: ubuntu-latest

    strategy:
      matrix:
        os: [ubuntu-latest, windows-2016]
        node-version: [12.x, 14.x]

    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v1
      with:
        node-version: ${{ matrix.node-version }}
    - name: npm install, and test
      run: |
        npm install
        npm test
      env:
        CI: true

When you commit to this branch, the workflow should run again. I'll respond when it is finished running.

Waiting on tests

Great! We've now got two nicely separated build and test jobs. Our custom workflow now accounts for:

• ✅ test against multiple targets so that we know if our supported operating systems and Node.js versions are working
• ✅ dedicated test job so that we can separate out build from test details

If you'd like to learn more about jobs, see:

• About GitHub Actions: Job in GitHub Help
• About CI: Job in GitHub Help
• Workflow syntax for GitHub Actions: jobs

Step 10: Run multiple jobs

⌨️ Activity: Wait for the result of multiple jobs in your workflow

No action required in this step - just waiting. I'll respond when the workflow runs your jobs.

Use the upload

The workflow has finished running!

You may notice build succeeded, but each of the test jobs failed. That's because the build artifacts created in build aren't available to the test job. Each job executes in a fresh instance of the virtual environment. This is due to the design of the virtual environments themselves.

So what do we do when we need the work product of one job in another? We can use the built-in artifact storage to save artifacts created from one job to be used in another job within the same workflow.

Step 11: Upload a job's build artifacts

Artifacts allow you to persist data after a job has completed, and share that data with another job in the same workflow. An artifact is a file or collection of files produced during a workflow run.

To upload artifacts to the artifact storage, we can use an action built by GitHub: actions/upload-artifacts.

⌨️ Activity: Use the upload action in your workflow file to save a job's build artifacts

You can follow the manual steps below, or accept the suggestion in the following comment.

1. Edit your workflow file
2. Add a step to your build job that uses the upload-artifacts action.

     build:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v2
         - name: npm install and build webpack
           run: |
             npm install
             npm run build
         - uses: actions/upload-artifact@main
           with:
             name: webpack artifacts
             path: public/

3. Commit your change to this branch

I'll respond when you commit to this branch.

Use the download

Great! The build artifacts will now be uploaded to the artifact storage. If you wait for the workflow to finish, you'll notice the test job still fails. This is for a number of reasons:

• jobs run in parallel, unless configured otherwise
• each job runs in its own virtual environment, so although we've pushed our artifacts to storage, the test job needs to retrieve them.

Step 12: Download a job's build artifacts

To remedy this, we'll run test only after build is finished so the artifacts are available.

Similar to the upload action to send artifacts to the storage, we'll use another action built by GitHub to download these previously uploaded artifacts from the build job: actions/download-artifact.

⌨️ Activity: Use the download action in your workflow file to access a prior job's build artifacts

You can follow the manual steps below, or accept the suggestions in the following comments.

1. Edit your workflow file
2. Configure the test job to run only after the build job is completed (we'll use ellipses ... to only show the parts of the workflow we're interested in, but you should not copy the ellipses directly):

     test:
       needs: build
       runs-on: ubuntu-latest
       ...

3. Add a step to your test job that uses the download-artifacts action.

     test:
       needs: build
       runs-on: ubuntu-latest
       ...
       steps:
       - uses: actions/checkout@v2
       - uses: actions/download-artifact@main
         with: 
           name: webpack artifacts
           path: public
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v1
         with:
           node-version: ${{ matrix.node-version }}
       - name: npm install, and test
         run: |
           npm install
           npm test
         env:
           CI: true

I'll respond when you've edited your workflow file.

Let's go to the next step.